home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / debug / ftt2.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  11KB  |  516 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. #include <dos.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include <conio.h>
  9.  
  10. #define BORDER 1
  11. #define REV_VID 0x70
  12. #define NORM_VID 0x1E
  13. #define MAX_FRAME 31
  14. #define BKSP 8
  15. #define F1 59
  16. #define F2 60
  17. #define F3 61
  18. #define F4 62
  19. #define F5 63
  20. #define F6 64
  21. #define F7 65
  22. #define F8 66
  23. #define F9 67
  24. #define F10 68
  25. #define HM  71   /* Home key     */
  26. #define UP  72   /* Up Arrow     */
  27. #define PU  73   /* Page Up      */
  28. #define LT  75   /* Left Arrow   */
  29. #define RT  77   /* Right Arrow  */
  30. #define END 79   /* End key      */
  31. #define DN  80   /* Down Arrow   */
  32. #define PD  81   /* Page Down    */
  33. #define ESC '\033'
  34. #define DIR 0x10
  35.  
  36. #define ROWS1 19
  37. #define ROWS2 23
  38. #define ROWS  25
  39. #define COLS 78
  40. #define L_W 20
  41. #define M_W 36
  42. #define R_W 20
  43. #define SCRNSIZE ((ROWS)*(COLS+2)*2)
  44. #define LAST (24 * 80)*2
  45.  
  46. #define M0C  4     /* Files maping col.s */
  47. #define M0L  14    /* Files maping rows  */
  48. #define M0F (((80 * 5) + 9)) * 2
  49. #define INTR 18*2
  50.  
  51. extern unsigned int attr1b;
  52. extern unsigned int *ptrs;
  53. extern int size;
  54. extern unsigned char row, col;
  55. extern int adapter;
  56. extern unsigned char far *videomem;
  57. extern int offset;
  58. extern int sw;
  59. extern char *path;
  60. extern char file[12];
  61. extern char tpname[31];
  62. extern char luname[8];
  63. extern char mode_name[8];
  64. extern char rcv_file[12];
  65. extern char dta[128];
  66.  
  67. extern char far *vid_mem;
  68. extern char far *sv;
  69. extern short cur_ln;
  70.  
  71. extern struct menu_frame {
  72.     int startx, endx, starty, endy;
  73.     unsigned char *p;
  74.     char **menu;
  75.     char *keys;
  76.     int border;
  77.     int count;
  78.     unsigned char attrib;
  79.     int active;
  80.     int curx, cury;
  81.     char *header;
  82.     unsigned char shd;
  83.     } frame[MAX_FRAME];
  84.  
  85. extern char p_dcl[21];
  86. extern unsigned char dr_ind[80];
  87. extern char c_pt[60];
  88. extern int drive_ind[10];
  89.  
  90. int pulldown(num)
  91. int num;
  92. {
  93.     int choice;
  94.  
  95.     if (frame[num].active == 0) {
  96.         save_video(num);
  97.         frame[num].active = 1;
  98.         if (frame[num].border) {
  99.             draw_border(num);
  100.         }
  101.     }
  102.     display_menu(num);
  103.     sfs(sv,vid_mem);
  104.     return get_resp(num);
  105. }
  106.  
  107. make_menu(num, menu, keys, count, x, y, border, attrib, shi)
  108. int  num;
  109. char **menu;
  110. char *keys;
  111. int count;
  112. int x, y;
  113. int border;
  114. unsigned char attrib;
  115. unsigned char shi;
  116. {
  117.     register int i, len;
  118.     int  dl;
  119.     int endx, endy, choice, vmode;
  120.     unsigned char *p;
  121.  
  122.     if (num > MAX_FRAME) {
  123.         printf("Too many menus");
  124.         exit(0);
  125.     }
  126.  
  127.     if (shi) {
  128.        dl = 1;
  129.     }
  130.     else
  131.        dl = 0;
  132.     len = 0;
  133.     for (i = 0; i < count; i++) {
  134.         if (strlen(menu[i]) > len) {
  135.             len = strlen(menu[i]);
  136.         }
  137.     }
  138.     endy = len + 2 + y;
  139.     endx = count + 1 + x;
  140.  
  141.     if ((p = malloc(((endx-x+2+dl)*(endy-y+2+dl)) * 2)) == NULL) {
  142.      printf("Allocation corrupted...\n");
  143.      exit (0);
  144.     }
  145.  
  146.     frame[num].startx = x;
  147.     frame[num].endx = endx;
  148.     frame[num].starty = y;
  149.     frame[num].endy = endy;
  150.     frame[num].p = p;
  151.     frame[num].menu = (char **)menu;
  152.     frame[num].border = border;
  153.     frame[num].keys = keys;
  154.     frame[num].count = count;
  155.     frame[num].attrib = attrib;
  156.     frame[num].active = 0;
  157.     frame[num].shd = shi;
  158.  
  159.     return 1;
  160. }
  161.  
  162. int display_menu(int num)
  163. {
  164.     char **m;
  165.     register int i, x;
  166.  
  167.     x = frame[num].startx + 1;
  168.     m = frame[num].menu;
  169.     for (i = 0; i < frame[num].count; i++, x++) {
  170.         if (m[i] != NULL) {
  171.             write_string(x, frame[num].starty + 1, m[i], frame[num].attrib);
  172.         }
  173.     }
  174. }
  175.  
  176.  draw_border(num)
  177. int num;
  178. {
  179.     register int i;
  180.     char far *v, far *t;
  181.  
  182.     v = vid_mem;
  183.     t = v;
  184.     for (i = frame[num].startx+1; i < frame[num].endx; i++) {
  185.         v += (i*160) + frame[num].starty * 2;
  186.         *v++ = 179;
  187.     v = t;
  188.     v += (i*160) + frame[num].endy * 2;
  189.     *v++ = 179;
  190.     v = t;
  191.     }
  192.     for (i = frame[num].starty+1; i < frame[num].endy; i++) {
  193.         v += (frame[num].startx * 160) + i * 2;
  194.         *v++ = 196;
  195.     v = t;
  196.     v += (frame[num].endx * 160) + i * 2;
  197.     *v++ = 196;
  198.     v = t;
  199.     }
  200.     write_char(frame[num].startx,frame[num].starty, 218, frame[num].attrib);
  201.     write_char(frame[num].startx,frame[num].endy, 191, frame[num].attrib);
  202.     write_char(frame[num].endx,frame[num].starty, 192, frame[num].attrib);
  203.     write_char(frame[num].endx,frame[num].endy, 217, frame[num].attrib);
  204. }
  205.  
  206. get_resp(num)
  207. int num;
  208. {
  209.     union inkey{
  210.         char ch[2];
  211.         int i;
  212.         } c;
  213.     int arrow_choice, key_choice;
  214.     int x, y;
  215.  
  216.     arrow_choice = 0;
  217.     x = frame[num].startx + 1;
  218.     y = frame[num].starty + 1;
  219.  
  220.     goto_xy(x, y);
  221.     write_string(x, y, frame[num].menu[0], REV_VID);
  222.  
  223.     for (;;) {
  224.     c.ch[0] = getch();
  225.     if (c.ch[0] == 0) {
  226.         c.ch[1] = getch();
  227.     }
  228.  
  229.     goto_xy(arrow_choice, y);
  230.     write_string(x + arrow_choice, y, frame[num].menu[arrow_choice], frame[num].attrib);
  231.     if (c.ch[0]) {
  232.         key_choice = is_in(frame[num].keys, tolower(c.ch[0]));
  233.         if (key_choice) {
  234.             return  key_choice - 1;
  235.         }
  236.         switch (c.ch[0]) {
  237.             case '\r' : return arrow_choice;
  238.             case ' '  : arrow_choice++;
  239.                         break;
  240.         case ESC: return -1;
  241.          }
  242.     }
  243.     else
  244.             {
  245.         switch (c.ch[1]) {
  246.                     case 72 : arrow_choice--;
  247.                               break;
  248.                     case 80 : arrow_choice++;
  249.                               break;
  250.                     case LT : return -2;
  251.                     case RT : return -3;
  252.                  }
  253.  
  254.             }
  255.     if (arrow_choice == frame[num].count) {
  256.         arrow_choice = 0;
  257.     }
  258.     if (arrow_choice < 0) {
  259.         arrow_choice = frame[num].count - 1;
  260.     }
  261.     goto_xy(x + arrow_choice, y);
  262.     write_string(x + arrow_choice, y, frame[num].menu[arrow_choice], REV_VID);
  263.     }
  264. }
  265.  
  266. write_string(x, y, p, attrib)
  267. int x, y;
  268. char *p;
  269. unsigned char attrib;
  270. {
  271.     register int i, j;
  272.     char far *v;
  273.     char _near *t1;
  274.     char _near *t2;
  275.     char _near *t3;
  276.     char _near *t4;
  277.  
  278.     v = vid_mem;
  279.     v += (x*160) + y*2;
  280.     t1 = FP_OFF( v );
  281.     t2 = FP_SEG( v );
  282.     t3 = FP_OFF( p );
  283.     t4 = FP_SEG( p );
  284.     _asm
  285.          {
  286.             mov  ax, word ptr t4[0]
  287.             mov  es, ax
  288.             mov  di, word ptr t3[0]
  289.             cld
  290.             mov  al, 0
  291.             mov  cx, 100
  292.       repne scasb       /* seek End of String */
  293.             jz   Found
  294.             mov  cx, 80 /* default length of string */
  295.             jmp short Move
  296.      Found:
  297.             mov  ax, 100
  298.             xchg ax, cx
  299.         sub  cx, ax /* length of string */
  300.         dec  cx
  301.         and  cx, cx
  302.         jz     WrtExit
  303.      Move:
  304.             push ds
  305.             push di
  306.             push si
  307.             mov  ax, word ptr t4[0]
  308.             mov  ds, ax
  309.             mov  si, word ptr t3[0]
  310.             mov  ax, word ptr t2[0]
  311.             mov  es, ax
  312.             mov  di, word ptr t1[0]
  313.             mov  ah, byte ptr attrib[0]
  314.      MvCycl:
  315.             lodsb
  316.             stosw
  317.             loop MvCycl;
  318.             pop  si
  319.             pop  di
  320.         pop  ds
  321.      WrtExit:
  322.          }
  323.   /*
  324.     for (i = y; *p; i++) {
  325.         *v++ = *p++;
  326.     *v++ = attrib;
  327.     }
  328.    */
  329. }
  330. write_n(x, y, p, attrib, n)
  331. int x, y;
  332. char *p;
  333. unsigned char attrib;
  334. unsigned int n;
  335. {
  336.     register int i, j;
  337.     char far *v;
  338.     char _near *t1;
  339.     char _near *t2;
  340.     char _near *t3;
  341.     char _near *t4;
  342.  
  343.     v = vid_mem;
  344.     v += (x*160) + y*2;
  345.     t1 = FP_OFF( v );
  346.     t2 = FP_SEG( v );
  347.     t3 = FP_OFF( p );
  348.     t4 = FP_SEG( p );
  349.     _asm
  350.          {
  351.             mov  cx, word ptr n[0]
  352.      Move:
  353.             push ds
  354.             push di
  355.             push si
  356.             mov  ax, word ptr t4[0]
  357.             mov  ds, ax
  358.             mov  si, word ptr t3[0]
  359.             mov  ax, word ptr t2[0]
  360.             mov  es, ax
  361.             mov  di, word ptr t1[0]
  362.             mov  ah, byte ptr attrib[0]
  363.      MvCycl:
  364.             lodsb
  365.             stosw
  366.             loop MvCycl;
  367.             pop  si
  368.             pop  di
  369.             pop  ds
  370.          }
  371. }
  372.  
  373. write_char(x, y, ch, attrib)
  374. int x, y;
  375. char ch;
  376. int attrib;
  377. {
  378.     register int i, j;
  379.     char far *v;
  380.  
  381.     v = vid_mem;
  382.     v += (x*160) + y*2;
  383.     *v++ = ch;
  384.     *v = attrib;
  385. }
  386.  
  387. save_video(num)
  388. int num;
  389. {
  390.     register int i, j;
  391.     int  dl;
  392.     char far *v, far *t;
  393.     char far *v1;
  394.     char far *t1;
  395.     char *buf_ptr;
  396.  
  397.     if (frame[num].shd) {
  398.        dl = 1; /* for shandow */
  399.     }
  400.     else
  401.        dl = 0;
  402.     buf_ptr = frame[num].p;
  403.     v = sv; /* save buffer */
  404.     v++;
  405.     v1 = vid_mem;
  406.     for (i = frame[num].starty; i < frame[num].endy + 1 + dl; i++) {
  407.         for (j = frame[num].startx; j < frame[num].endx + 1+ dl; j++) {
  408.             t = (v + (j*160) + i*2);
  409.             t1 = (v1 + (j*160) + i*2);
  410.             *buf_ptr++ = *t1++;
  411.             *buf_ptr++ = *t1;
  412.         if ((i == frame[num].endy+1)||(j == frame[num].endx+1)) {
  413.         if ((i == (frame[num].starty))||(j == frame[num].startx)) {
  414.         }
  415.         else
  416.                    *t = 0x07;
  417.             }
  418.         else
  419.         {
  420.                    *(t - 1) = ' ';
  421.                    *t = frame[num].attrib;
  422.         }
  423.         }
  424.     }
  425.     sfs(vid_mem, sv);
  426. }
  427.  
  428. int restore_video(int num)
  429. {
  430.     register int i, j;
  431.     int  dl;
  432.     char far *v, far *t;
  433.     char *buf_ptr;
  434.  
  435.     if (!frame[num].active) {
  436.         return 0;
  437.     }
  438.     if (frame[num].shd) {
  439.        dl = 1; /* for shandow */
  440.     }
  441.     else
  442.        dl = 0;
  443.     buf_ptr = frame[num].p;
  444.     v = sv;
  445.     t = v;
  446.     for (i = frame[num].starty; i < frame[num].endy + 1 + dl; i++) {
  447.         for (j = frame[num].startx; j < frame[num].endx + 1 + dl; j++) {
  448.             v = t;
  449.             v += (j*160) + i*2;
  450.             *v++ = *buf_ptr++;
  451.             *v = *buf_ptr++;
  452.          }
  453.     }
  454.     frame[num].active = 0;
  455.     sfs(vid_mem, sv);
  456. }
  457.  
  458.  cls(int ind)
  459. {
  460.     union REGS r;
  461.     char far *t;
  462.     register int i;
  463.  
  464.     r.h.ah = 6;
  465.     r.h.al = 0;
  466.     r.h.ch = 0;
  467.     r.h.cl = 0;
  468.     r.h.dh = 24;
  469.     r.h.dl = 79;
  470.     r.h.bh = 7;
  471.     int86(0x10, &r, &r);
  472.     if (ind == 1) {
  473.        t = vid_mem;
  474.        t++;
  475.        for (i = 0; i < 2000; i++) {
  476.            *t =  0x31;
  477.            t++;
  478.            *t = 176;
  479.            t ++;
  480.        }
  481.     }
  482. }
  483.  
  484.  goto_xy(x, y)
  485. int x, y;
  486. {
  487.     union REGS r;
  488.  
  489.     r.h.ah = 2;
  490.     r.h.dl = y;
  491.     r.h.dh = x;
  492.     r.h.bh = 0;
  493.     int86(0x10, &r, &r);
  494. }
  495.  
  496. video_mode()
  497. {
  498.     union REGS r;
  499.  
  500.     r.h.ah = 15;
  501.     return int86(0x10, &r, &r) & 255;
  502. }
  503.  
  504. is_in(s, c)
  505. char *s, c;
  506. {
  507.     register int i;
  508.  
  509.     for (i = 0; *s; i++) {
  510.         if (*s++ == c) {
  511.             return i + 1;
  512.         }
  513.     }
  514.     return 0;
  515. }
  516.